home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / apps / 41 / proffsrc / lookup.c < prev    next >
C/C++ Source or Header  |  1986-07-17  |  3KB  |  170 lines
  1. /*
  2.  * from K&R "The C Programming language"
  3.  * Table lookup routines
  4.  *
  5.  */
  6. #define INLOOK 1
  7.  
  8. #include <stdio.h>
  9. #include "proff.h"
  10.  
  11. struct
  12. lexlist    (*(*lextable))[];/* global pointer for lexical analyser hash table */
  13.  
  14. /*
  15.  * hash - for a hash value for string s
  16.  *
  17.  */
  18. int hash(s)
  19. char *s;
  20. {
  21.     int    hashval;
  22.  
  23.     for (hashval = 0; *s != '\0';)
  24.         hashval += *s++;
  25.     return (hashval % HASHMAX);
  26. }
  27.  
  28. /*
  29.  * lookup - lookup for a string s in the hash table
  30.  *
  31.  */
  32. struct hashlist
  33. *lookup(s, hashtab)
  34. char *s;
  35. struct hashlist *hashtab[];
  36. {
  37.     struct hashlist *np;
  38.  
  39.     for (np = hashtab[hash(s)]; np != NULL; np = np->next)
  40.         if (strcmp(s, np->name) == 0)
  41.             return(np);    /* found     */
  42.     return(NULL);        /* not found */
  43. }
  44.  
  45. /*
  46.  * install - install a string name in hashtable and its value def
  47.  * at a given hashtable.
  48.  */
  49. struct hashlist
  50. *install(name,def,hashtab)
  51. char *name;
  52. char *def;
  53. struct hashlist *hashtab[];
  54. {
  55.     int hashval;
  56.     struct hashlist *np, *lookup();
  57.     char *strsave(), *malloc();
  58.  
  59.     if ((np = lookup(name, hashtab)) == NULL) {    /* not found.. */
  60.         np = (struct hashlist *) malloc(sizeof(*np));
  61.         p_memoryus += sizeof(*np);
  62.         if (np == NULL)
  63.             return(NULL);
  64.         if ((np->name = strsave(name)) == NULL)
  65.             return(NULL);
  66.         hashval = hash(np->name);
  67.         np->next = hashtab[hashval];
  68.         hashtab[hashval] = np;
  69.     } else                    /* found..     */
  70.         free(np->def);            /* free prev.  */
  71.     if ((np->def = strsave(def)) == NULL)
  72.         return(NULL);
  73.     return(np);
  74. }
  75.  
  76. /*
  77.  * strsave - save string s somewhere
  78.  *
  79.  */
  80. char
  81. *strsave(s)
  82. char *s;
  83. {
  84.     char *p, *malloc();
  85.     register int n;
  86.  
  87.     n = strlen(s) + 1;
  88.     if ((p = malloc(n)) != NULL) {
  89.         p_memoryus += n;
  90.         strcpy(p, s);
  91.     }
  92.     return(p);
  93. }
  94.  
  95. /*
  96.  * lexinstal - instal a string name in hashtable and its value
  97.  *           used by lexical analyser to quickly match a token
  98.  *           and return its lexical value.
  99.  *
  100.  */
  101. struct lexlist
  102. *lexinstal(name,val,flag,lextable)
  103. char *name;
  104. int val;
  105. int flag;
  106. struct lexlist *lextable[];
  107. {
  108.     int hashval;
  109.     struct lexlist *np,*lexlook();
  110.     char *strsave(), *malloc();
  111.  
  112.     if ((np = lexlook(name,lextable)) == NULL) {    /* not found.. */
  113.         np = (struct lexlist *) malloc(sizeof(*np));
  114.         p_memoryus += sizeof(*np);
  115.         if (np == NULL)
  116.             return(NULL);
  117.         if ((np->name = strsave(name)) == NULL)
  118.             return(NULL);
  119.         hashval = hash(np->name);
  120.         np->link = lextable[hashval];
  121.         lextable[hashval] = np;
  122.     }
  123.     np->val = val;                /* replace prev */
  124.     np->flag = flag;
  125.     return(np);
  126. }
  127.  
  128. /*
  129.  * lexlook - lookup for a string s in the hash table
  130.  *         used by lexinstal only.
  131.  *
  132.  */
  133. struct lexlist
  134. *lexlook(s,table)
  135. char *s;
  136. struct lexlist *table[];
  137. {
  138.     struct lexlist *np;
  139.  
  140.     for (np = table[hash(s)]; np != NULL; np = np->link)
  141.         if (strcmp(s, np->name) == 0)
  142.             return(np);    /* found     */
  143.     return(NULL);        /* not found */
  144. }
  145.  
  146. /*
  147.  * remove an item from the hash table forever
  148.  *
  149.  */
  150. struct lexlist
  151. *remove(s, table)
  152. char *s;
  153. struct lexlist *table[];
  154. {
  155.     struct lexlist *np, *xp;
  156.  
  157.     np = table[hash(s)];
  158.     xp = np; 
  159.     while (np != NULL) {
  160.         if (strcmp(s, np->name) == 0) {
  161.             xp->link = np->link;    /* remove the link */
  162.             return(np);        /* return the lost */
  163.         }
  164.         xp = np; 
  165.         np = np->link;
  166.     }
  167.     return(NULL);
  168. }
  169.  
  170.